import java.lang.reflect.Array;
import java.util.Arrays;
public class MyArraylist {
        public int[] array;
        public int usedSize;//0
        private static final int DEFAULT_SIZE = 10;//默认容量
        public MyArraylist() {
            this.array = new int[DEFAULT_SIZE];//默认容量
        }
        /**
         * 打印顺序表:
         * 根据usedSize判断即可
         */
        public void display() {
            for (int i = 0; i < this.usedSize; i++) {
                System.out.print(array[i] + " ");
            }
        }

        // 新增元素,默认在数组最后新增
        public void add(int data) {
                if(isFull()){
                        checkPos(data);
                        grow();
                }
                this.array[this.usedSize]=data;
                this.usedSize++;
        }
        /**
         * 判断当前的顺序表是不是满的！
         *
         * @return true:满   false代表空
         */
        public void grow(){
                this.array= Arrays.copyOf
                        (this.array,2*this.array.length);
        }
        public boolean isFull() {
                return this.usedSize==array.length;
        }
        private boolean checkPos(int pos) throws  PosIllegal {
                if(pos<0||pos>usedSize){
        throw new PosIllegal("Pos位置不合法！！");
        }
            return true;//合法
        }
        // 在 pos 位置新增元素
        public void add(int pos, int data) {
                try {
                        if (isFull()) {
                                checkPos(pos);
                                grow();
                        }
                        for (int i = usedSize - 1; i >= pos; i--) {
                                this.array[i + 1] = array[i];
                        }
                        array[pos] = data;
                        this.usedSize++;
                }catch(PosIllegal e){
                        System.out.println("插入元素pos位置不合法..");
                        e.printStackTrace();
                }
        }

        // 判定是否包含某个元素
        public boolean contains(int toFind) {
                for (int i = 0; i <usedSize ; i++) {
                     if(array[i]==toFind){
                             System.out.println("该数组包含此元素");
                             return true;
                     }
                }
                return false;
        }

        // 查找某个元素对应的位置
        public int indexOf(int toFind) {
                for (int i = 0; i <usedSize ; i++) {
                        if (array[i]==toFind) {
                        return i;
                        }
                }
                return 0;
        }

        // 获取 pos 位置的元素
        public int get(int pos) {
                try {
                        for (int i = 0; i <usedSize ; i++) {
                                if(array[i]==pos)
                                        return array[i];
                        }

                } catch (PosIllegal e) {
                        e.printStackTrace();

                } catch (EmptyException e) {
                        e.printStackTrace();
                }
                return -1;
        }
        private boolean isEmpty() {
                return usedSize==0;
        }
        private void checkEmpty(){
                if(isEmpty()){
                        throw new EmptyException("此顺序表为空");
                }
        }
        private void checkPos2(int pos) throws PosIllegal{
                if(pos < 0 || pos >= usedSize) {
                        throw new PosIllegal("Pos位置不合法！！");
                }
        }
        // 给 pos 位置的元素设为【更新为】 value
        public void set(int pos, int value) {
                try{checkEmpty();
                        checkPos(pos);
                        checkEmpty();
                        array[pos]=value;
                }catch (EmptyException e){
                        e.printStackTrace();
                }catch (PosIllegal e) {
                        e.printStackTrace();
                }

        }

        /**
         * 删除第一次出现的关键字key
         *
         * @param key
         */
        public void remove(int key) {
                try {
                        checkEmpty();
                        int pos = indexOf(key);
                        if(pos == -1) {
                                return;
                        }
                        for (int i = pos; i < usedSize-1; i++) {
                                array[i] = array[i+1];
                        }
                        usedSize--;
                }catch (EmptyException e) {
                        e.printStackTrace();
                }
        }

        // 获取顺序表长度
        public int size() {
            return this.usedSize;
        }

        // 清空顺序表
        public void clear() {
                usedSize = 0;
        }
    }

